﻿using System.Text;

using BodaNetCommunications.CommBase.Interfaces;
using BodaNetCommunications.Nodes;
using BodaNetCommunications.Utilities.ComTypes;
using BodaNetCommunications.Utilities.LogHelper;
using BodaNetCommunications.Utilities.Results;

namespace BodaNetCommunications.Cores
{

    //
    // 摘要:
    //     所有的和设备或是交互类统一读写标准，公开了如何读写对方的一些api接口，并支持基于特性的读写操作
    //     All unified read and write standards for devices and interaction classes, expose
    //     how to read and write some API interfaces of each other, and support feature-based
    //     read and write operations
    //
    // 言论：
    //     Modbus类，PLC类均实现了本接口，可以基于本接口实现统一所有的不同种类的设备的数据交互
    public interface ICommReadWrite
    {
        //
        // 摘要:
        //     组件的日志工具，支持日志记录，只要实例化后，当前网络的基本信息，就以LogNet.HslMessageDegree.DEBUG等级进行输出
        //
        //     The component's logging tool supports logging. As long as the instantiation of
        //     the basic network information, the output will be output at LogNet.HslMessageDegree.DEBUG
        //
        //
        // 言论：
        //     只要实例化即可以记录日志，实例化的对象需要实现接口 LogNet.ILogNet ，本组件提供了三个日志记录类，你可以实现基于
        //     LogNet.ILogNet 的对象。
        ILogNet? LogNet { get; set; }

        //
        // 摘要:
        //     当前连接的唯一ID号，默认为长度20的guid码加随机数组成，方便列表管理，也可以自己指定
        //     The unique ID number of the current connection. The default is a 20-digit guid
        //     code plus a random number.
        //
        // 言论：
        //     当前的唯一连接ID信息在DTU的模式下，将发挥关键作用，标记唯一的DTU ID
        string? ConnectionId { get; set; }


        BodaResult ReadNodes(List<RequestNode> nodes, Action<List<RequestNode>>? inputCallback = null, CancellationToken token = default);

        /// <summary>
        /// 根据数据地址和数据类型选择对应的读取数据方法，并返回值
        /// </summary>
        /// <param name="address"></param>
        /// <param name="dataType"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        BodaResult Read(string address, DataType dataType, ushort length = 1);

        /// <summary>
        /// 根据地址判断类型，然后读取数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        BodaResult ReadByAddress(string address, ushort length = 1);

        /// <summary>
        /// 通过地址解析出数据类型，并读取数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="dataType">数据类型字符串</param>
        /// <param name="length"></param>
        /// <returns></returns>
        BodaResult Read(string address, string dataType, ushort length = 1);

        //
        // 摘要:
        //     批量读取字节数组信息，需要指定地址和长度，返回原始的字节数组
        //     Batch read byte array information, need to specify the address and length, return
        //     the original byte array
        //
        // 参数:
        //   address:
        //     数据地址
        //
        //   length:
        //     数据长度
        //
        // 返回结果:
        //     带有成功标识的byte[]数组
        BodaResult<byte[]> Read(string address, ushort length);

        //
        // 摘要:
        //     写入原始的byte数组数据到指定的地址，返回是否写入成功
        //     Write the original byte array data to the specified address, and return whether
        //     the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     是否写入成功
        BodaResult Write(string address, byte[] value);

        //
        // 摘要:
        //     批量读取System.Boolean数组信息，需要指定地址和长度，返回System.Boolean 数组
        //     Batch read System.Boolean array information, need to specify the address and
        //     length, return System.Boolean array
        //
        // 参数:
        //   address:
        //     数据地址
        //
        //   length:
        //     数据长度
        //
        // 返回结果:
        //     带有成功标识的 bool[] 数组
        BodaResult<bool[]> ReadBool(string address, ushort length);

        //
        // 摘要:
        //     读取单个的System.Boolean数据信息
        //     Read a single System.Boolean data message
        //
        // 参数:
        //   address:
        //     数据地址
        //
        // 返回结果:
        //     带有成功标识的 bool 值
        BodaResult<bool> ReadBool(string address);

        //
        // 摘要:
        //     批量写入System.Boolean数组数据，返回是否成功
        //     Batch write System.Boolean array data, return whether the write was successful
        //
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     是否写入成功
        BodaResult Write(string address, bool[] value);

        //
        // 摘要:
        //     写入单个的System.Boolean数据，返回是否成功
        //     Write a single System.Boolean data, and return whether the write was successful
        //
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     是否写入成功
        BodaResult Write(string address, bool value);

        //
        // 摘要:
        //     读取16位的有符号的整型数据
        //     Read 16-bit signed integer data
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的short数据
        BodaResult<short> ReadInt16(string address);

        //
        // 摘要:
        //     读取16位的有符号整型数组
        //     Read 16-bit signed integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     带有成功标识的short数组
        BodaResult<short[]> ReadInt16(string address, ushort length);

        //
        // 摘要:
        //     读取16位的无符号整型
        //     Read 16-bit unsigned integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的ushort数据
        BodaResult<ushort> ReadUInt16(string address);

        //
        // 摘要:
        //     读取16位的无符号整型数组
        //     Read 16-bit unsigned integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     带有成功标识的ushort数组
        BodaResult<ushort[]> ReadUInt16(string address, ushort length);

        //
        // 摘要:
        //     读取32位的有符号整型
        //     Read 32-bit signed integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的int数据
        BodaResult<int> ReadInt32(string address);

        //
        // 摘要:
        //     读取32位有符号整型数组
        //     Read 32-bit signed integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的int数组
        BodaResult<int[]> ReadInt32(string address, ushort length);

        //
        // 摘要:
        //     读取32位的无符号整型
        //     Read 32-bit unsigned integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的uint数据
        BodaResult<uint> ReadUInt32(string address);

        //
        // 摘要:
        //     读取32位的无符号整型数组
        //     Read 32-bit unsigned integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的uint数组
        BodaResult<uint[]> ReadUInt32(string address, ushort length);

        //
        // 摘要:
        //     读取64位的有符号整型
        //     Read 64-bit signed integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的long数据
        BodaResult<long> ReadInt64(string address);

        //
        // 摘要:
        //     读取64位的有符号整型数组
        //     Read 64-bit signed integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的long数组
        BodaResult<long[]> ReadInt64(string address, ushort length);

        //
        // 摘要:
        //     读取64位的无符号整型
        //     Read 64-bit unsigned integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的ulong数据
        BodaResult<ulong> ReadUInt64(string address);

        //
        // 摘要:
        //     读取64位的无符号整型的数组
        //     Read 64-bit unsigned integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带成功标志的结果数据对象
        BodaResult<ulong[]> ReadUInt64(string address, ushort length);

        //
        // 摘要:
        //     读取单浮点数据
        //     Read single floating point data
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的float数据
        BodaResult<float> ReadFloat(string address);

        //
        // 摘要:
        //     读取单浮点精度的数组
        //     Read single floating point array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的float数组
        BodaResult<float[]> ReadFloat(string address, ushort length);

        //
        // 摘要:
        //     读取双浮点的数据
        //     Read double floating point data
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的double数据
        BodaResult<double> ReadDouble(string address);

        //
        // 摘要:
        //     读取双浮点数据的数组
        //     Read double floating point data array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的double数组
        BodaResult<double[]> ReadDouble(string address, ushort length);

        //
        // 摘要:
        //     读取字符串数据，默认为最常见的ASCII编码
        //     Read string data, default is the most common ASCII encoding
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数据长度
        //
        // 返回结果:
        //     带有成功标识的string数据
        BodaResult<string> ReadString(string address, ushort length);

        //
        // 摘要:
        //     使用指定的编码，读取字符串数据
        //     Reads string data using the specified encoding
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数据长度
        //
        //   encoding:
        //     指定的自定义的编码
        //
        // 返回结果:
        //     带有成功标识的string数据
        BodaResult<string> ReadString(string address, ushort length, Encoding encoding);

        //
        // 摘要:
        //     等待指定地址的System.Boolean值为指定的值，可以指定刷新数据的频率，等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //     Waiting for the System.Boolean value of the specified address to be the specified
        //     value, you can specify the frequency of refreshing the data, and the timeout
        //     time to wait. If the timeout time is -1, it is an indefinite wait.
        //
        // 参数:
        //   address:
        //     其实地址
        //
        //   waitValue:
        //     等待检测是值
        //
        //   readInterval:
        //     读取的频率
        //
        //   waitTimeout:
        //     等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //
        // 返回结果:
        //     是否等待成功的结果对象，一旦通信失败，或是等待超时就返回失败。否则返回成功，并告知调用方等待了多久。
        BodaResult<TimeSpan> Wait(string address, bool waitValue, int readInterval, int waitTimeout);

        //
        // 摘要:
        //     等待指定地址的System.Int16值为指定的值，可以指定刷新数据的频率，等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //     Waiting for the System.Int16 value of the specified address to be the specified
        //     value, you can specify the frequency of refreshing the data, and the timeout
        //     time to wait. If the timeout time is -1, it is an indefinite wait.
        //
        // 参数:
        //   address:
        //     其实地址
        //
        //   waitValue:
        //     等待检测是值
        //
        //   readInterval:
        //     读取的频率
        //
        //   waitTimeout:
        //     等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //
        // 返回结果:
        //     是否等待成功的结果对象，一旦通信失败，或是等待超时就返回失败。否则返回成功，并告知调用方等待了多久。
        BodaResult<TimeSpan> Wait(string address, short waitValue, int readInterval, int waitTimeout);

        //
        // 摘要:
        //     等待指定地址的System.UInt16值为指定的值，可以指定刷新数据的频率，等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //     Waiting for the System.UInt16 value of the specified address to be the specified
        //     value, you can specify the frequency of refreshing the data, and the timeout
        //     time to wait. If the timeout time is -1, it is an indefinite wait.
        //
        // 参数:
        //   address:
        //     其实地址
        //
        //   waitValue:
        //     等待检测是值
        //
        //   readInterval:
        //     读取的频率
        //
        //   waitTimeout:
        //     等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //
        // 返回结果:
        //     是否等待成功的结果对象，一旦通信失败，或是等待超时就返回失败。否则返回成功，并告知调用方等待了多久。
        BodaResult<TimeSpan> Wait(string address, ushort waitValue, int readInterval, int waitTimeout);

        //
        // 摘要:
        //     等待指定地址的System.Int32值为指定的值，可以指定刷新数据的频率，等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //     Waiting for the System.Int32 value of the specified address to be the specified
        //     value, you can specify the frequency of refreshing the data, and the timeout
        //     time to wait. If the timeout time is -1, it is an indefinite wait.
        //
        // 参数:
        //   address:
        //     其实地址
        //
        //   waitValue:
        //     等待检测是值
        //
        //   readInterval:
        //     读取的频率
        //
        //   waitTimeout:
        //     等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //
        // 返回结果:
        //     是否等待成功的结果对象，一旦通信失败，或是等待超时就返回失败。否则返回成功，并告知调用方等待了多久。
        BodaResult<TimeSpan> Wait(string address, int waitValue, int readInterval, int waitTimeout);

        //
        // 摘要:
        //     等待指定地址的System.UInt32值为指定的值，可以指定刷新数据的频率，等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //     Waiting for the System.UInt32 value of the specified address to be the specified
        //     value, you can specify the frequency of refreshing the data, and the timeout
        //     time to wait. If the timeout time is -1, it is an indefinite wait.
        //
        // 参数:
        //   address:
        //     其实地址
        //
        //   waitValue:
        //     等待检测是值
        //
        //   readInterval:
        //     读取的频率
        //
        //   waitTimeout:
        //     等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //
        // 返回结果:
        //     是否等待成功的结果对象，一旦通信失败，或是等待超时就返回失败。否则返回成功，并告知调用方等待了多久。
        BodaResult<TimeSpan> Wait(string address, uint waitValue, int readInterval, int waitTimeout);

        //
        // 摘要:
        //     等待指定地址的System.Int64值为指定的值，可以指定刷新数据的频率，等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //     Waiting for the System.Int64 value of the specified address to be the specified
        //     value, you can specify the frequency of refreshing the data, and the timeout
        //     time to wait. If the timeout time is -1, it is an indefinite wait.
        //
        // 参数:
        //   address:
        //     其实地址
        //
        //   waitValue:
        //     等待检测是值
        //
        //   readInterval:
        //     读取的频率
        //
        //   waitTimeout:
        //     等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //
        // 返回结果:
        //     是否等待成功的结果对象，一旦通信失败，或是等待超时就返回失败。否则返回成功，并告知调用方等待了多久。
        BodaResult<TimeSpan> Wait(string address, long waitValue, int readInterval, int waitTimeout);

        //
        // 摘要:
        //     等待指定地址的System.UInt64值为指定的值，可以指定刷新数据的频率，等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //     Waiting for the System.UInt64 value of the specified address to be the specified
        //     value, you can specify the frequency of refreshing the data, and the timeout
        //     time to wait. If the timeout time is -1, it is an indefinite wait.
        //
        // 参数:
        //   address:
        //     其实地址
        //
        //   waitValue:
        //     等待检测是值
        //
        //   readInterval:
        //     读取的频率
        //
        //   waitTimeout:
        //     等待的超时时间，如果超时时间为-1的话，则是无期限等待。
        //
        // 返回结果:
        //     是否等待成功的结果对象，一旦通信失败，或是等待超时就返回失败。否则返回成功，并告知调用方等待了多久。
        BodaResult<TimeSpan> Wait(string address, ulong waitValue, int readInterval, int waitTimeout);

        Task<BodaResult<TimeSpan>> WaitAsync(string address, bool waitValue, int readInterval, int waitTimeout);

        Task<BodaResult<TimeSpan>> WaitAsync(string address, short waitValue, int readInterval, int waitTimeout);

        Task<BodaResult<TimeSpan>> WaitAsync(string address, ushort waitValue, int readInterval, int waitTimeout);

        Task<BodaResult<TimeSpan>> WaitAsync(string address, int waitValue, int readInterval, int waitTimeout);

        Task<BodaResult<TimeSpan>> WaitAsync(string address, uint waitValue, int readInterval, int waitTimeout);

        Task<BodaResult<TimeSpan>> WaitAsync(string address, long waitValue, int readInterval, int waitTimeout);

        Task<BodaResult<TimeSpan>> WaitAsync(string address, ulong waitValue, int readInterval, int waitTimeout);

        //
        // 摘要:
        //     写入short数据，返回是否成功
        //     Write short data, returns whether success
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, short value);

        //
        // 摘要:
        //     写入short数组，返回是否成功
        //     Write short array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, short[] values);

        //
        // 摘要:
        //     写入ushort数据，返回是否成功
        //     Write ushort data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, ushort value);

        //
        // 摘要:
        //     写入ushort数组，返回是否成功
        //     Write ushort array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, ushort[] values);

        //
        // 摘要:
        //     写入int数据，返回是否成功
        //     Write int data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, int value);

        //
        // 摘要:
        //     写入int[]数组，返回是否成功
        //     Write int array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, int[] values);

        //
        // 摘要:
        //     写入uint数据，返回是否成功
        //     Write uint data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, uint value);

        //
        // 摘要:
        //     写入uint[]数组，返回是否成功
        //     Write uint array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, uint[] values);

        //
        // 摘要:
        //     写入long数据，返回是否成功
        //     Write long data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, long value);

        //
        // 摘要:
        //     写入long数组，返回是否成功
        //     Write long array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, long[] values);

        //
        // 摘要:
        //     写入ulong数据，返回是否成功
        //     Write ulong data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, ulong value);

        //
        // 摘要:
        //     写入ulong数组，返回是否成功
        //     Write ulong array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, ulong[] values);

        //
        // 摘要:
        //     写入float数据，返回是否成功
        //     Write float data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, float value);

        //
        // 摘要:
        //     写入float数组，返回是否成功
        //     Write float array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, float[] values);

        //
        // 摘要:
        //     写入double数据，返回是否成功
        //     Write double data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, double value);

        //
        // 摘要:
        //     写入double数组，返回是否成功
        //     Write double array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, double[] values);

        //
        // 摘要:
        //     写入字符串信息，编码为ASCII
        //     Write string information, encoded as ASCII
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, string value);

        //
        // 摘要:
        //     写入字符串信息，需要指定的编码信息
        //     Write string information, need to specify the encoding information
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        //   encoding:
        //     指定的编码信息
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, string value, Encoding encoding);

        //
        // 摘要:
        //     写入指定长度的字符串信息，如果超出，就截断字符串，如果长度不足，那就补0操作，编码为ASCII
        //     Write string information of the specified length. If it exceeds the value, the
        //     string is truncated. If the length is not enough, it is filled with 0 and the
        //     encoding is ASCII.
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        //   length:
        //     字符串的长度
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, string value, int length);

        //
        // 摘要:
        //     写入指定长度的字符串信息，如果超出，就截断字符串，如果长度不足，那就补0操作，编码为指定的编码信息
        //     Write string information of the specified length. If it exceeds the value, the
        //     string is truncated. If the length is not enough, then the operation is complemented
        //     with 0 , you should specified the encoding information
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        //   length:
        //     字符串的长度
        //
        //   encoding:
        //     指定的编码信息
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        BodaResult Write(string address, string value, int length, Encoding encoding);

        //
        // 摘要:
        //     读取自定义的数据类型，需要继承自IDataTransfer接口，返回一个新的类型的实例对象。
        //     To read a custom data type, you need to inherit from the IDataTransfer interface
        //     and return an instance object of a new type.
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 类型参数:
        //   T:
        //     自定义的类型
        //
        // 返回结果:
        //     带有成功标识的自定义类型数据
        //
        // 言论：
        //     需要是定义一个类，选择好相对于的ByteTransform实例，才能调用该方法。
        BodaResult<T> ReadCustomer<T>(string address) where T : IDataTransfer, new();

        //
        // 摘要:
        //     读取自定义的数据类型，需要继承自IDataTransfer接口，传入一个实例，对这个实例进行赋值，并返回该实例的对象。
        //     To read a custom data type, you need to inherit from the IDataTransfer interface,
        //     pass in an instance, assign a value to this instance, and return the object of
        //     the instance.
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   obj:
        //     实例
        //
        // 类型参数:
        //   T:
        //     自定义的类型
        //
        // 返回结果:
        //     带有成功标识的自定义类型数据
        //
        // 言论：
        //     需要是定义一个类，选择好相对于的ByteTransform实例，才能调用该方法。
        BodaResult<T> ReadCustomer<T>(string address, T obj) where T : IDataTransfer, new();

        //
        // 摘要:
        //     写入自定义类型的数据，该类型必须继承自IDataTransfer接口
        //     Write data of a custom type, which must inherit from the IDataTransfer interface
        //
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 类型参数:
        //   T:
        //     类型对象
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        //
        // 言论：
        //     需要是定义一个类，选择好相对于的IDataTransfer实例，才能调用该方法。
        BodaResult WriteCustomer<T>(string address, T value) where T : IDataTransfer, new();

        //
        // 摘要:
        //     读取支持Hsl特性的数据内容，该特性为Reflection.HslDeviceAddressAttribute，详细参考api文档说明
        //
        //     Read the data content of the Hsl attribute. The attribute is Reflection.HslDeviceAddressAttribute,
        //     please refer to the api documentation for details.
        //
        // 类型参数:
        //   T:
        //     自定义的数据类型对象
        //
        // 返回结果:
        //     包含是否成功的结果对象
        BodaResult<T> Read<T>() where T : class, new();

        //
        // 摘要:
        //     写入支持Hsl特性的数据，返回是否写入成功，该特性为Reflection.HslDeviceAddressAttribute，详细参考api文档说明
        //
        //     Write data that supports the Hsl attribute, and return whether the write was
        //     successful. The attribute is Reflection.HslDeviceAddressAttribute,
        //     please refer to the api documentation for details.
        //
        // 类型参数:
        //   T:
        //     自定义的数据类型对象
        //
        // 返回结果:
        //     包含是否成功的结果对象
        //
        // 异常:
        //   T:System.ArgumentNullException:
        BodaResult Write<T>(T data) where T : class, new();

        //
        // 摘要:
        //     读取结构体类型的数据，根据结构体自身的定义，读取原始字节数组，然后解析出实际的结构体数据，结构体需要实现Reflection.HslStructAttribute特性
        //
        //
        // 参数:
        //   address:
        //     PLC的地址信息
        //
        //   length:
        //     读取的地址长度信息
        //
        // 类型参数:
        //   T:
        //     类型对象信息
        //
        // 返回结果:
        //     如果成功，返回成功的结构体对象
        BodaResult<T> ReadStruct<T>(string address, ushort length) where T : class, new();

        //
        // 摘要:
        //     异步批量读取字节数组信息，需要指定地址和长度，返回原始的字节数组
        //     Asynchronous batch read byte array information, need to specify the address and
        //     length, return the original byte array
        //
        // 参数:
        //   address:
        //     数据地址
        //
        //   length:
        //     数据长度
        //
        // 返回结果:
        //     带有成功标识的byte[]数组
        Task<BodaResult<byte[]>> ReadAsync(string address, ushort length);

        //
        // 摘要:
        //     异步写入原始的byte数组数据到指定的地址，返回是否写入成功
        //     Asynchronously writes the original byte array data to the specified address,
        //     and returns whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, byte[] value);

        //
        // 摘要:
        //     异步批量读取System.Boolean数组信息，需要指定地址和长度，返回System.Boolean 数组
        //     Asynchronously batch read System.Boolean array information, need to specify the
        //     address and length, return System.Boolean array
        //
        // 参数:
        //   address:
        //     数据地址
        //
        //   length:
        //     数据长度
        //
        // 返回结果:
        //     带有成功标识的byte[]数组
        Task<BodaResult<bool[]>> ReadBoolAsync(string address, ushort length);

        //
        // 摘要:
        //     异步读取单个的System.Boolean数据信息
        //     Asynchronously read a single System.Boolean data message
        //
        // 参数:
        //   address:
        //     数据地址
        //
        // 返回结果:
        //     带有成功标识的byte[]数组
        Task<BodaResult<bool>> ReadBoolAsync(string address);

        //
        // 摘要:
        //     异步批量写入System.Boolean数组数据，返回是否成功
        //     Asynchronously batch write System.Boolean array data, return success
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, bool[] value);

        //
        // 摘要:
        //     异步批量写入System.Boolean数组数据，返回是否成功
        //     Asynchronously batch write System.Boolean array data, return success
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, bool value);

        //
        // 摘要:
        //     异步读取16位的有符号的整型数据
        //     Asynchronously read 16-bit signed integer data
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的short数据
        Task<BodaResult<short>> ReadInt16Async(string address);

        //
        // 摘要:
        //     异步读取16位的有符号整型数组
        //     Asynchronously read 16-bit signed integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     带有成功标识的short数组
        Task<BodaResult<short[]>> ReadInt16Async(string address, ushort length);

        //
        // 摘要:
        //     异步读取16位的无符号整型
        //     Asynchronously read 16-bit unsigned integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的ushort数据
        Task<BodaResult<ushort>> ReadUInt16Async(string address);

        //
        // 摘要:
        //     异步读取16位的无符号整型数组
        //     Asynchronously read 16-bit unsigned integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     读取的数组长度
        //
        // 返回结果:
        //     带有成功标识的ushort数组
        Task<BodaResult<ushort[]>> ReadUInt16Async(string address, ushort length);

        //
        // 摘要:
        //     异步读取32位的有符号整型
        //     Asynchronously read 32-bit signed integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的int数据
        Task<BodaResult<int>> ReadInt32Async(string address);

        //
        // 摘要:
        //     异步读取32位有符号整型数组
        //     Asynchronously read 32-bit signed integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的int数组
        Task<BodaResult<int[]>> ReadInt32Async(string address, ushort length);

        //
        // 摘要:
        //     异步读取32位的无符号整型
        //     Asynchronously read 32-bit unsigned integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的uint数据
        Task<BodaResult<uint>> ReadUInt32Async(string address);

        //
        // 摘要:
        //     异步读取32位的无符号整型数组
        //     Asynchronously read 32-bit unsigned integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的uint数组
        Task<BodaResult<uint[]>> ReadUInt32Async(string address, ushort length);

        //
        // 摘要:
        //     异步读取64位的有符号整型
        //     Asynchronously read 64-bit signed integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的long数据
        Task<BodaResult<long>> ReadInt64Async(string address);

        //
        // 摘要:
        //     异步读取64位的有符号整型数组
        //     Asynchronously read 64-bit signed integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的long数组
        Task<BodaResult<long[]>> ReadInt64Async(string address, ushort length);

        //
        // 摘要:
        //     异步读取64位的无符号整型
        //     Asynchronously read 64-bit unsigned integer
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的ulong数据
        Task<BodaResult<ulong>> ReadUInt64Async(string address);

        //
        // 摘要:
        //     异步读取64位的无符号整型的数组
        //     Asynchronously read 64-bit unsigned integer array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的ulong数组
        Task<BodaResult<ulong[]>> ReadUInt64Async(string address, ushort length);

        //
        // 摘要:
        //     异步读取单浮点数据
        //     Asynchronously read single floating point data
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的float数据
        Task<BodaResult<float>> ReadFloatAsync(string address);

        //
        // 摘要:
        //     异步读取单浮点精度的数组
        //     Asynchronously read single floating point array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的float数组
        Task<BodaResult<float[]>> ReadFloatAsync(string address, ushort length);

        //
        // 摘要:
        //     异步读取双浮点的数据
        //     Asynchronously read double floating point data
        //
        // 参数:
        //   address:
        //     起始地址
        //
        // 返回结果:
        //     带有成功标识的double数据
        Task<BodaResult<double>> ReadDoubleAsync(string address);

        //
        // 摘要:
        //     异步读取双浮点数据的数组
        //     Asynchronously read double floating point data array
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数组长度
        //
        // 返回结果:
        //     带有成功标识的double数组
        Task<BodaResult<double[]>> ReadDoubleAsync(string address, ushort length);

        //
        // 摘要:
        //     异步读取字符串数据，默认为最常见的ASCII编码
        //     Asynchronously read string data, default is the most common ASCII encoding
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数据长度
        //
        // 返回结果:
        //     带有成功标识的string数据
        Task<BodaResult<string>> ReadStringAsync(string address, ushort length);

        //
        // 摘要:
        //     异步使用指定的编码，读取字符串数据
        //     Asynchronously reads string data using the specified encoding
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   length:
        //     数据长度
        //
        //   encoding:
        //     指定的自定义的编码
        //
        // 返回结果:
        //     带有成功标识的string数据
        Task<BodaResult<string>> ReadStringAsync(string address, ushort length, Encoding encoding);

        //
        // 摘要:
        //     异步写入short数据，返回是否成功
        //     Asynchronously write short data, returns whether success
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, short value);

        //
        // 摘要:
        //     异步写入short数组，返回是否成功
        //     Asynchronously write short array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, short[] values);

        //
        // 摘要:
        //     异步写入ushort数据，返回是否成功
        //     Asynchronously write ushort data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, ushort value);

        //
        // 摘要:
        //     异步写入ushort数组，返回是否成功
        //     Asynchronously write ushort array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, ushort[] values);

        //
        // 摘要:
        //     异步写入int数据，返回是否成功
        //     Asynchronously write int data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, int value);

        //
        // 摘要:
        //     异步写入int[]数组，返回是否成功
        //     Asynchronously write int array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, int[] values);

        //
        // 摘要:
        //     异步写入uint数据，返回是否成功
        //     Asynchronously write uint data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, uint value);

        //
        // 摘要:
        //     异步写入uint[]数组，返回是否成功
        //     Asynchronously write uint array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, uint[] values);

        //
        // 摘要:
        //     异步写入long数据，返回是否成功
        //     Asynchronously write long data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, long value);

        //
        // 摘要:
        //     异步写入long数组，返回是否成功
        //     Asynchronously write long array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, long[] values);

        //
        // 摘要:
        //     异步写入ulong数据，返回是否成功
        //     Asynchronously write ulong data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, ulong value);

        //
        // 摘要:
        //     异步写入ulong数组，返回是否成功
        //     Asynchronously write ulong array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, ulong[] values);

        //
        // 摘要:
        //     异步写入float数据，返回是否成功
        //     Asynchronously write float data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, float value);

        //
        // 摘要:
        //     异步写入float数组，返回是否成功
        //     Asynchronously write float array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, float[] values);

        //
        // 摘要:
        //     异步写入double数据，返回是否成功
        //     Asynchronously write double data, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, double value);

        //
        // 摘要:
        //     异步写入double数组，返回是否成功
        //     Asynchronously write double array, return whether the write was successful
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   values:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, double[] values);

        //
        // 摘要:
        //     异步写入字符串信息，编码为ASCII
        //     Asynchronously write string information, encoded as ASCII
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, string value);

        //
        // 摘要:
        //     异步写入字符串信息，需要指定的编码信息
        //     Asynchronously write string information, need to specify the encoding information
        //
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        //   encoding:
        //     指定的编码信息
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, string value, Encoding encoding);

        //
        // 摘要:
        //     异步写入指定长度的字符串信息，如果超出，就截断字符串，如果长度不足，那就补0操作，编码为ASCII
        //     Asynchronously write string information of the specified length. If it exceeds
        //     the value, the string is truncated. If the length is not enough, it is filled
        //     with 0 and the encoding is ASCII.
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        //   length:
        //     字符串的长度
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, string value, int length);

        //
        // 摘要:
        //     异步写入指定长度的字符串信息，如果超出，就截断字符串，如果长度不足，那就补0操作，编码为指定的编码信息
        //     Asynchronously write string information of the specified length. If it exceeds
        //     the value, the string is truncated. If the length is not enough, then the operation
        //     is complemented with 0 , you should specified the encoding information
        //
        // 参数:
        //   address:
        //     起始地址
        //
        //   value:
        //     写入值
        //
        //   length:
        //     字符串的长度
        //
        //   encoding:
        //     指定的编码信息
        //
        // 返回结果:
        //     带有成功标识的结果类对象
        Task<BodaResult> WriteAsync(string address, string value, int length, Encoding encoding);

        Task<BodaResult<T>> ReadCustomerAsync<T>(string address) where T : IDataTransfer, new();

        Task<BodaResult<T>> ReadCustomerAsync<T>(string address, T obj) where T : IDataTransfer, new();

        Task<BodaResult> WriteCustomerAsync<T>(string address, T value) where T : IDataTransfer, new();

        //
        // 摘要:
        //     异步读取支持Hsl特性的数据内容，该特性为Reflection.HslDeviceAddressAttribute，详细参考api文档说明
        //
        //     Asynchronously read the data content of the Hsl attribute. The attribute is Reflection.HslDeviceAddressAttribute,
        //     please refer to the api documentation for details.
        //
        // 类型参数:
        //   T:
        //     自定义的数据类型对象
        //
        // 返回结果:
        //     包含是否成功的结果对象
        Task<BodaResult<T>> ReadAsync<T>() where T : class, new();

        //
        // 摘要:
        //     异步写入支持Hsl特性的数据，返回是否写入成功，该特性为Reflection.HslDeviceAddressAttribute，详细参考api文档说明
        //
        //     Asynchronously write data that supports the Hsl attribute, and return whether
        //     the write was successful. The attribute is Reflection.HslDeviceAddressAttribute,
        //     please refer to the api documentation for details.
        //
        // 类型参数:
        //   T:
        //     自定义的数据类型对象
        //
        // 返回结果:
        //     包含是否成功的结果对象
        //
        // 异常:
        //   T:System.ArgumentNullException:
        Task<BodaResult> WriteAsync<T>(T data) where T : class, new();

        Task<BodaResult<T>> ReadStructAsync<T>(string address, ushort length) where T : class, new();


        Task<BodaResult<string>> ReceiveMsgAsync(int timeout = 2000, int bytesLen = 1024, CancellationToken cancellationToken = default);

        Task<BodaResult> SendMsgAsync(string msg, int timeout = 1500);
    }
}
